"""
安全评价视图模块

此模块包含安全评价系统的所有视图函数，提供完整的REST API接口。
包括安全评价的创建、读取、更新、删除等核心功能。

主要功能：
- 安全评价CRUD操作
- 评价数据统计分析
- 默认指标值管理
- 评价报告导出
- 输入验证和安全检查

作者：矿山安全评价系统开发团队
版本：1.0.0
更新时间：2025-10-12
"""

import json
import logging
from datetime import datetime
from typing import Dict, Any, Optional

from django.shortcuts import get_object_or_404
from django.http import JsonResponse, HttpResponse, HttpRequest
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from django.utils import timezone
from django.core.paginator import Paginator
from django.db.models import Avg, Count, Q
from django.core.exceptions import ValidationError
from django.db import transaction

from .models import SafetyEvaluation

# 配置日志记录器
logger = logging.getLogger(__name__)

# ========== 隐患追踪自动创建函数 ==========

def auto_create_hazard_tracking_from_evaluation(evaluation: SafetyEvaluation) -> list:
    """
    从安全评价自动创建隐患追踪任务
    
    当安全等级为C级或D级时，自动检查所有安全指标，
    为值小于50的指标创建隐患追踪任务。
    
    Args:
        evaluation: 安全评价实例
    
    Returns:
        list: 创建的隐患追踪任务列表，每个元素包含task_id等信息
    """
    try:
        # 检查安全等级是否为C级或D级
        safety_level = evaluation.get_safety_level()
        if not safety_level or ('C级' not in safety_level and 'D级' not in safety_level):
            logger.debug(f"评估 {evaluation.evaluation_id} 安全等级为 {safety_level}，无需创建隐患追踪任务")
            return []
        
        # 导入隐患追踪模型
        from hazard.models import HazardTracking
        from datetime import timedelta
        
        # 指标中文名称映射
        indicators_mapping = {
            'worker_safety_awareness': '工人安全意识与操作能力',
            'management_capability': '管理人员的管理能力',
            'mining_equipment_integrity': '采掘设备完好率',
            'ventilation_equipment_integrity': '矿井通风设备完好率',
            'gas_monitoring_equipment_integrity': '瓦斯监测设备完好率',
            'fire_prevention_equipment_integrity': '防火及消防设施完好率',
            'drainage_equipment_integrity': '井下排水设备完好率',
            'hoisting_equipment_integrity': '矿井提升设备完好率',
            'power_system_integrity': '供电系统设备完好率',
            'air_supply_demand_ratio': '风量供需比',
            'roof_management_difficulty': '顶板管理难易程度',
            'coal_spontaneous_combustion_tendency': '煤层自燃发火倾向性',
            'safety_management_implementation': '安全管理制度及落实率',
            'emergency_response_completeness': '应急响应机制完善率',
            'safety_inspection_implementation': '安全检查整改落实率',
        }
        
        # 整改建议模板库
        remediation_templates = {
            'management_capability': {
                'condition': '能力评分 < 50',
                'level': '较危险',
                'suggestion': '系统检测到矿井管理人员管理能力存在不足。请加强管理人员安全管理培训，优化安全职责分工，并落实定期巡查与监督机制。整改完成后请上传培训记录及管理改进方案。'
            },
            'worker_safety_awareness': {
                'condition': '安全意识评分 < 50',
                'level': '较危险',
                'suggestion': '模型分析表明工人安全意识不足。请开展班组安全教育与实操培训，提升员工安全操作能力，确保规范作业。整改完成后上传培训签到表及照片。'
            },
            'mining_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '采掘设备状态异常。请进行巡检、维修，落实预防性维护制度，确保设备安全运行。整改完成后上传检修清单。'
            },
            'ventilation_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '通风设备存在异常。请检查主扇、辅扇及管道，清理障碍物，确保风量充足和通风稳定。整改完成后上传检查及维修记录。'
            },
            'gas_monitoring_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '瓦斯监测设备异常。请校准监测仪器，保证实时在线监控及报警功能有效。整改完成后上传校准记录。'
            },
            'fire_prevention_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '消防设施存在缺陷。请检查灭火器、喷淋系统、消防水源，并修复或更换损坏设备。整改完成后上传测试记录。'
            },
            'drainage_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '井下排水设备存在故障。请检查水泵、管路及阀门，确保排水畅通。整改完成后上传运行记录。'
            },
            'hoisting_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '矿井提升设备存在故障风险。请检查钢丝绳、制动装置及安全保护措施。整改完成后上传检查记录。'
            },
            'power_system_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '供电系统设备异常。请检查供电线路、开关及设备，确保供电可靠。整改完成后上传检查记录。'
            },
            'air_supply_demand_ratio': {
                'condition': '比值 < 50',
                'level': '较危险',
                'suggestion': '风量不足。请优化通风系统布局，确保工作面风量满足安全要求。整改完成后上传调整记录。'
            },
            'roof_management_difficulty': {
                'condition': '管理难度评分 < 50',
                'level': '较危险',
                'suggestion': '顶板管理存在风险。请加强顶板支护、监测及巡查，确保顶板稳定。整改完成后上传检查记录。'
            },
            'coal_spontaneous_combustion_tendency': {
                'condition': '倾向性评分 < 50',
                'level': '较危险',
                'suggestion': '采取惰性气体注入、充填隔离等技术防止自燃发火。'
            },
            'safety_management_implementation': {
                'condition': '落实率 < 50',
                'level': '较危险',
                'suggestion': '安全制度执行不到位。请完善制度、明确责任、强化监督，整改后上传制度落实记录。'
            },
            'emergency_response_completeness': {
                'condition': '完善率 < 50',
                'level': '较危险',
                'suggestion': '应急预案不完善。请完善应急响应措施，组织演练并上传演练记录。'
            },
            'safety_inspection_implementation': {
                'condition': '落实率 < 50',
                'level': '较危险',
                'suggestion': '隐患整改滞后。请建立闭环管理，确保所有隐患按时整改并复核，上传整改结果。'
            }
        }
        
        # 获取所有指标数据
        indicators_dict = evaluation.get_safety_indicators_dict()
        
        # 找出值小于50的指标
        low_score_indicators = []
        for field_name, value in indicators_dict.items():
            if value < 50.0:
                low_score_indicators.append(field_name)
        
        if not low_score_indicators:
            logger.debug(f"评估 {evaluation.evaluation_id} 没有指标值小于50，无需创建隐患追踪任务")
            return []
        
        # 使用事务批量创建隐患追踪任务
        created_tasks = []
        with transaction.atomic():
            for field_name in low_score_indicators:
                try:
                    # 检查是否已存在相同评价和指标的隐患任务（避免重复创建）
                    existing_task = HazardTracking.objects.filter(
                        safety_evaluation=evaluation,
                        indicator_name=indicators_mapping.get(field_name, field_name)
                    ).first()
                    
                    if existing_task:
                        logger.debug(f"评估 {evaluation.evaluation_id} 的指标 {field_name} 已存在隐患任务 {existing_task.task_id}，跳过创建")
                        continue
                    
                    # 获取指标值
                    indicator_value = indicators_dict.get(field_name, 0)
                    
                    # 获取整改建议模板
                    template = remediation_templates.get(field_name, {})
                    indicator_name = indicators_mapping.get(field_name, field_name)
                    
                    # 根据安全等级确定隐患等级
                    # D级矿山使用'D级(较差)'，C级矿山使用'C级(一般)'
                    if 'D级' in safety_level:
                        hazard_safety_level = 'D级(较差)'
                    else:
                        hazard_safety_level = 'C级(一般)'
                    
                    # 设置截止日期为指派日期后7天
                    deadline = timezone.now() + timedelta(days=7)
                    
                    # 创建隐患追踪任务
                    hazard = HazardTracking.objects.create(
                        mine_name=evaluation.mine_name,
                        indicator_name=indicator_name,
                        safety_level=hazard_safety_level,
                        trigger_condition=template.get('condition', f'指标值 {indicator_value} < 50'),
                        remediation_suggestion=template.get('suggestion', f'{indicator_name}指标值低于50，需要整改。'),
                        responsible_person='待指派',
                        deadline_date=deadline,
                        safety_evaluation=evaluation,
                        remarks=f'由安全评价报告自动生成（评价编号: {evaluation.evaluation_id}，指标值: {indicator_value}）'
                    )
                    
                    created_tasks.append({
                        'task_id': hazard.task_id,
                        'indicator_name': hazard.indicator_name,
                        'safety_level': hazard.safety_level,
                        'indicator_value': indicator_value
                    })
                    
                    logger.info(f"成功创建隐患追踪任务: {hazard.task_id} for 指标 {indicator_name}")
                    
                except Exception as task_error:
                    logger.warning(f"创建隐患任务失败，指标: {field_name}，错误: {task_error}", exc_info=True)
                    continue
            
            if created_tasks:
                logger.info(f"评估 {evaluation.evaluation_id} 自动创建了 {len(created_tasks)} 个隐患追踪任务")
            else:
                logger.info(f"评估 {evaluation.evaluation_id} 未创建新的隐患追踪任务（可能已存在）")
            
            return created_tasks
            
    except Exception as e:
        logger.error(f"自动创建隐患追踪任务失败 (评估: {evaluation.evaluation_id}): {str(e)}", exc_info=True)
        # 不影响评估的创建/更新，只记录错误
        return []

# ========== 常量定义 ==========
MAX_PAGE_SIZE = 100
DEFAULT_PAGE_SIZE = 10
MIN_INDICATOR_VALUE = 0.0
MAX_INDICATOR_VALUE = 100.0

# ========== 辅助函数 ==========

def create_error_response(message: str, status_code: int = 400, error_code: Optional[str] = None) -> JsonResponse:
    """
    创建标准化的错误响应
    
    Args:
        message: 错误消息
        status_code: HTTP状态码
        error_code: 错误代码
    
    Returns:
        JsonResponse: 标准化的错误响应
    """
    response_data = {
        'success': False,
        'error': message,
        'timestamp': timezone.now().isoformat()
    }
    if error_code:
        response_data['error_code'] = error_code
    
    logger.warning(f"API错误: {message} (状态码: {status_code})")
    return JsonResponse(response_data, status=status_code)


def create_success_response(data: Any = None, message: str = None) -> JsonResponse:
    """
    创建标准化的成功响应
    
    Args:
        data: 响应数据
        message: 成功消息
    
    Returns:
        JsonResponse: 标准化的成功响应
    """
    response_data = {
        'success': True,
        'timestamp': timezone.now().isoformat()
    }
    if data is not None:
        response_data['data'] = data
    if message:
        response_data['message'] = message
    
    return JsonResponse(response_data)


def validate_indicator_value(value: Any, field_name: str) -> float:
    """
    验证安全指标值
    
    Args:
        value: 待验证的值
        field_name: 字段名称
    
    Returns:
        float: 验证后的浮点数值
    
    Raises:
        ValidationError: 当值无效时抛出
    """
    try:
        float_value = float(value)
        if not (MIN_INDICATOR_VALUE <= float_value <= MAX_INDICATOR_VALUE):
            raise ValidationError(f'{field_name} 必须在 {MIN_INDICATOR_VALUE} 到 {MAX_INDICATOR_VALUE} 之间')
        return float_value
    except (ValueError, TypeError):
        raise ValidationError(f'{field_name} 必须是有效的数字')


def validate_pagination_params(request: HttpRequest) -> tuple:
    """
    验证分页参数
    
    Args:
        request: HTTP请求对象
    
    Returns:
        tuple: (页码, 页面大小)
    """
    try:
        page = max(1, int(request.GET.get('page', 1)))
        page_size = min(MAX_PAGE_SIZE, max(1, int(request.GET.get('page_size', DEFAULT_PAGE_SIZE))))
        return page, page_size
    except (ValueError, TypeError):
        return 1, DEFAULT_PAGE_SIZE


# ========== 核心视图函数 ==========

@csrf_exempt
@require_http_methods(["GET", "POST"])
def safety_evaluation_list(request: HttpRequest) -> JsonResponse:
    """
    安全评价列表API
    
    GET请求：获取评价列表，支持分页和多条件筛选
    POST请求：创建新的安全评价记录
    
    查询参数（GET）：
        - page: 页码（默认1）
        - page_size: 每页大小（默认10，最大100）
        - mine_name: 矿山名称（模糊搜索）
        - region: 所属区域（精确匹配）
        - category: 评价类别（精确匹配）
        - evaluator: 评价人员（模糊搜索）
    
    Returns:
        JsonResponse: 包含评价列表和分页信息的JSON响应
    """
    if request.method == 'GET':
        try:
            # 验证分页参数
            page, page_size = validate_pagination_params(request)
            
            # 获取筛选参数
            mine_name = request.GET.get('mine_name', '').strip()
            region = request.GET.get('region', '').strip()
            category = request.GET.get('category', '').strip()
            evaluator = request.GET.get('evaluator', '').strip()
            
            # 构建查询集
            queryset = SafetyEvaluation.objects.select_related().order_by('-created_at')
            
            # 应用筛选条件
            if mine_name:
                queryset = queryset.filter(mine_name__icontains=mine_name)
            if region:
                queryset = queryset.filter(region=region)
            if category:
                queryset = queryset.filter(evaluation_category=category)
            if evaluator:
                queryset = queryset.filter(evaluator_name__icontains=evaluator)
            
            # 分页处理
            paginator = Paginator(queryset, page_size)
            
            if page > paginator.num_pages and paginator.num_pages > 0:
                return create_error_response('请求的页码超出范围', 404, 'PAGE_OUT_OF_RANGE')
            
            page_obj = paginator.get_page(page)
            
            # 构建响应数据
            evaluations = []
            for evaluation in page_obj:
                try:
                    evaluation_data = {
                        'id': evaluation.id,
                        'evaluation_id': evaluation.evaluation_id,
                        'mine_name': evaluation.mine_name,
                        'evaluator_name': evaluation.evaluator_name,
                        'evaluation_date': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else None,
                        'region': evaluation.get_region_display(),
                        'evaluation_category': evaluation.get_evaluation_category_display(),
                        'comprehensive_score': round(evaluation.calculate_comprehensive_score(), 4),
                        'safety_level': evaluation.get_safety_level(),
                        'created_at': evaluation.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                        'updated_at': evaluation.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
                    }
                    evaluations.append(evaluation_data)
                except Exception as eval_error:
                    logger.warning(f"处理评价记录 {evaluation.id} 时出错: {eval_error}")
                    continue
            
            pagination_info = {
                'current_page': page,
                'total_pages': paginator.num_pages,
                'total_count': paginator.count,
                'page_size': page_size,
                'has_next': page_obj.has_next(),
                'has_previous': page_obj.has_previous(),
            }
            
            return create_success_response({
                'evaluations': evaluations,
                'pagination': pagination_info,
                'filters': {
                    'mine_name': mine_name,
                    'region': region,
                    'category': category,
                    'evaluator': evaluator,
                }
            })
            
        except Exception as e:
            logger.error(f"获取安全评价列表失败: {str(e)}", exc_info=True)
            return create_error_response('获取评价列表失败，请稍后重试', 500, 'LIST_FETCH_ERROR')
    
    elif request.method == 'POST':
        return create_safety_evaluation(request)


@csrf_exempt  
@require_http_methods(["POST"])
def create_safety_evaluation(request: HttpRequest) -> JsonResponse:
    """
    创建新的安全评价记录
    
    请求体应包含以下字段：
    - 必需字段：evaluator_name, mine_name, region, evaluation_category
    - 可选字段：evaluation_date, 各项安全指标值
    
    所有安全指标值应在0.0-1.0范围内，若未提供将使用默认值
    
    Returns:
        JsonResponse: 包含创建结果的JSON响应
    """
    try:
        # 解析请求数据
        try:
            data = json.loads(request.body.decode('utf-8'))
            logger.info(f"收到评价创建请求，数据: {data}")
        except (json.JSONDecodeError, UnicodeDecodeError) as e:
            logger.error(f"JSON解析错误: {e}")
            return create_error_response('请求数据格式错误', 400, 'INVALID_JSON')
        
        # 验证必需字段
        required_fields = ['evaluator_name', 'mine_name', 'region', 'evaluation_category']
        missing_fields = [field for field in required_fields if not data.get(field)]
        if missing_fields:
            logger.warning(f"缺少必需字段: {missing_fields}")
            return create_error_response(f'缺少必需字段: {", ".join(missing_fields)}', 400, 'MISSING_REQUIRED_FIELDS')
        
        # 验证新增字段
        if data.get('production_capacity', 0) <= 0:
            return create_error_response('生产能力必须大于0', 400, 'INVALID_PRODUCTION_CAPACITY')
        
        if data.get('service_life', 0) <= 0:
            return create_error_response('服务年限必须大于0', 400, 'INVALID_SERVICE_LIFE')
        
        if not data.get('development_methods') or len(data.get('development_methods', [])) == 0:
            return create_error_response('请至少选择一种开拓方式', 400, 'MISSING_DEVELOPMENT_METHODS')
        
        if not data.get('transport_method'):
            return create_error_response('请选择运输方式', 400, 'MISSING_TRANSPORT_METHOD')
        
        # 验证字段长度和格式 (放宽限制)
        evaluator_name = data.get('evaluator_name', '').strip()
        mine_name = data.get('mine_name', '').strip()
        
        logger.info(f"验证评价人员姓名: '{evaluator_name}', 长度: {len(evaluator_name)}")
        logger.info(f"验证矿山名称: '{mine_name}', 长度: {len(mine_name)}")
        
        # 放宽验证：只要不是空字符串即可
        if not evaluator_name:
            return create_error_response('评价人员姓名不能为空', 400, 'INVALID_EVALUATOR_NAME')
        if not mine_name:
            return create_error_response('矿山名称不能为空', 400, 'INVALID_MINE_NAME')
        
        # 定义安全指标字段和默认值（0-100范围）
        indicator_fields = {
            'worker_safety_awareness': 75.0,
            'management_capability': 80.0,
            'mining_equipment_integrity': 85.0,
            'ventilation_equipment_integrity': 90.0,
            'gas_monitoring_equipment_integrity': 88.0,
            'fire_prevention_equipment_integrity': 82.0,
            'drainage_equipment_integrity': 87.0,
            'hoisting_equipment_integrity': 91.0,
            'power_system_integrity': 89.0,
            'air_supply_demand_ratio': 78.0,
            'roof_management_difficulty': 70.0,
            'coal_spontaneous_combustion_tendency': 65.0,
            'safety_management_implementation': 83.0,
            'emergency_response_completeness': 77.0,
            'safety_inspection_implementation': 81.0,
        }
        
        # 验证并准备安全指标数据
        validated_indicators = {}
        for field_name, default_value in indicator_fields.items():
            try:
                value = data.get(field_name, default_value)
                validated_indicators[field_name] = validate_indicator_value(value, field_name)
            except ValidationError as ve:
                return create_error_response(str(ve), 400, 'INVALID_INDICATOR_VALUE')
        
        # 处理评价日期
        evaluation_date = data.get('evaluation_date')
        if evaluation_date:
            try:
                if isinstance(evaluation_date, str):
                    evaluation_date = datetime.strptime(evaluation_date, '%Y-%m-%d').date()
            except ValueError:
                return create_error_response('评价日期格式错误，应为 YYYY-MM-DD', 400, 'INVALID_DATE_FORMAT')
        else:
            evaluation_date = timezone.now().date()
        
        # 使用事务创建安全评价记录
        with transaction.atomic():
            evaluation = SafetyEvaluation(
                # 基本信息
                evaluator_name=evaluator_name,  # 使用已验证的变量
                mine_name=mine_name,            # 使用已验证的变量
                region=data['region'],
                evaluation_category=data['evaluation_category'],
                evaluation_date=evaluation_date,
                
                # 新增矿山基本信息字段
                affiliated_enterprise=data.get('affiliated_enterprise', ''),
                production_capacity=data.get('production_capacity', 100.0),
                service_life=data.get('service_life', 30),
                development_methods=data.get('development_methods', []),
                transport_method=data.get('transport_method', ''),
                
                # 生产系统信息
                current_production_system=data.get('current_production_system', 'mining_system'),
                production_systems=data.get('production_systems', {}),
                
                # 安全指标
                **validated_indicators
            )
            
            # 保存到数据库 (save方法会自动生成evaluation_id)
            evaluation.save()
            
            # 现在可以进行完整性验证 (evaluation_id已生成)
            # evaluation.full_clean()  # 可选，因为save()已经做了基本验证
            
            logger.info(f"成功创建安全评价记录: {evaluation.evaluation_id}")
            
            # 计算综合得分和安全等级并保存到数据库
            comprehensive_score = evaluation.calculate_comprehensive_score()
            safety_level = evaluation.get_safety_level()
            evaluation.comprehensive_score = comprehensive_score
            evaluation.safety_level = safety_level
            evaluation.save(update_fields=['comprehensive_score', 'safety_level'])
            
            # 自动创建隐患追踪任务（如果安全等级为C级或D级）
            created_hazard_tasks = auto_create_hazard_tracking_from_evaluation(evaluation)
            
            return create_success_response({
                'id': evaluation.id,
                'evaluation_id': evaluation.evaluation_id,
                'mine_name': evaluation.mine_name,
                'evaluator_name': evaluation.evaluator_name,
                'evaluation_date': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else None,
                'region': evaluation.region,
                'region_display': evaluation.get_region_display(),
                'evaluation_category': evaluation.evaluation_category,
                'evaluation_category_display': evaluation.get_evaluation_category_display(),
                
                # 新增矿山基本信息字段
                'affiliated_enterprise': evaluation.affiliated_enterprise,
                'production_capacity': evaluation.production_capacity,
                'service_life': evaluation.service_life,
                'development_methods': evaluation.development_methods,
                'development_methods_display': evaluation.get_development_methods_display(),
                'transport_method': evaluation.transport_method,
                'transport_method_display': evaluation.get_transport_method_display(),
                
                # 生产系统信息
                'current_production_system': evaluation.current_production_system,
                'production_systems': evaluation.production_systems,
                'current_system_info': evaluation.get_current_system_info(),
                'all_systems_summary': evaluation.get_all_systems_summary(),
                
                'comprehensive_score': round(comprehensive_score, 4),
                'safety_level': safety_level,
                'indicators': evaluation.get_safety_indicators_dict(),
                'mine_basic_info': evaluation.get_mine_basic_info_dict(),
                'created_at': evaluation.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                'hazard_tasks_created': len(created_hazard_tasks),
                'hazard_tasks': created_hazard_tasks if created_hazard_tasks else None,
            }, '安全评价创建成功' + (f'，已自动创建{len(created_hazard_tasks)}个隐患追踪任务' if created_hazard_tasks else ''))
        
    except ValidationError as ve:
        logger.warning(f"安全评价数据验证失败: {ve}")
        return create_error_response(f'数据验证失败: {ve}', 400, 'VALIDATION_ERROR')
    except Exception as e:
        logger.error(f"创建安全评价失败: {str(e)}", exc_info=True)
        return create_error_response('创建评价失败，请稍后重试', 500, 'CREATE_ERROR')


@csrf_exempt
@require_http_methods(["GET", "PUT", "DELETE"])
def safety_evaluation_detail(request: HttpRequest, evaluation_id: int) -> JsonResponse:
    """
    安全评价详情API
    
    GET: 获取评价详细信息
    PUT: 更新评价数据
    DELETE: 删除评价记录
    
    Args:
        evaluation_id: 安全评价记录的ID
    
    Returns:
        JsonResponse: 包含操作结果的JSON响应
    """
    try:
        evaluation = get_object_or_404(SafetyEvaluation, pk=evaluation_id)
    except Exception as e:
        logger.warning(f"安全评价记录不存在: ID={evaluation_id}")
        return create_error_response('评价记录不存在', 404, 'EVALUATION_NOT_FOUND')
    
    if request.method == 'GET':
        try:
            # 构建详细信息响应
            evaluation_data = {
                'id': evaluation.id,
                'evaluation_id': evaluation.evaluation_id,
                'evaluator_name': evaluation.evaluator_name,
                'mine_name': evaluation.mine_name,
                'region': evaluation.region,
                'region_display': evaluation.get_region_display(),
                'evaluation_category': evaluation.evaluation_category,
                'evaluation_category_display': evaluation.get_evaluation_category_display(),
                'evaluation_date': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else None,
                
                # 新增矿山基本信息字段
                'affiliated_enterprise': evaluation.affiliated_enterprise,
                'production_capacity': evaluation.production_capacity,
                'service_life': evaluation.service_life,
                'development_methods': evaluation.development_methods,
                'development_methods_display': evaluation.get_development_methods_display(),
                'transport_method': evaluation.transport_method,
                'transport_method_display': evaluation.get_transport_method_display(),
                
                # 生产系统信息
                'current_production_system': evaluation.current_production_system,
                'production_systems': evaluation.production_systems,
                'current_system_info': evaluation.get_current_system_info(),
                'all_systems_summary': evaluation.get_all_systems_summary(),
                
                # 安全指标详情
                'indicators': evaluation.get_safety_indicators_dict(),
                
                # 计算结果
                'comprehensive_score': round(evaluation.calculate_comprehensive_score(), 4),
                'safety_level': evaluation.get_safety_level(),
                
                # 元数据
                'created_at': evaluation.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                'updated_at': evaluation.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
            }
            
            return create_success_response(evaluation_data)
            
        except Exception as e:
            logger.error(f"获取安全评价详情失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
            return create_error_response('获取评价详情失败', 500, 'DETAIL_FETCH_ERROR')
    
    elif request.method == 'PUT':
        try:
            # 解析请求数据
            try:
                data = json.loads(request.body.decode('utf-8'))
            except (json.JSONDecodeError, UnicodeDecodeError):
                return create_error_response('请求数据格式错误', 400, 'INVALID_JSON')
            
            # 使用事务更新记录
            with transaction.atomic():
                # 更新基本信息
                if 'evaluator_name' in data and data['evaluator_name'].strip():
                    if len(data['evaluator_name'].strip()) < 2:
                        return create_error_response('评价人员姓名至少需要2个字符', 400)
                    evaluation.evaluator_name = data['evaluator_name'].strip()
                
                if 'mine_name' in data and data['mine_name'].strip():
                    if len(data['mine_name'].strip()) < 2:
                        return create_error_response('矿山名称至少需要2个字符', 400)
                    evaluation.mine_name = data['mine_name'].strip()
                
                if 'region' in data:
                    evaluation.region = data['region']
                
                if 'evaluation_category' in data:
                    evaluation.evaluation_category = data['evaluation_category']
                
                if 'evaluation_date' in data and data['evaluation_date']:
                    try:
                        if isinstance(data['evaluation_date'], str):
                            evaluation.evaluation_date = datetime.strptime(data['evaluation_date'], '%Y-%m-%d').date()
                    except ValueError:
                        return create_error_response('评价日期格式错误，应为 YYYY-MM-DD', 400)
                
                # 更新新增矿山基本信息字段
                if 'affiliated_enterprise' in data:
                    evaluation.affiliated_enterprise = data['affiliated_enterprise']
                
                if 'production_capacity' in data:
                    if data['production_capacity'] <= 0:
                        return create_error_response('生产能力必须大于0', 400)
                    evaluation.production_capacity = data['production_capacity']
                
                if 'service_life' in data:
                    if data['service_life'] <= 0:
                        return create_error_response('服务年限必须大于0', 400)
                    evaluation.service_life = data['service_life']
                
                if 'development_methods' in data:
                    if not data['development_methods'] or len(data['development_methods']) == 0:
                        return create_error_response('请至少选择一种开拓方式', 400)
                    evaluation.development_methods = data['development_methods']
                
                if 'transport_method' in data:
                    if not data['transport_method']:
                        return create_error_response('请选择运输方式', 400)
                    evaluation.transport_method = data['transport_method']
                
                # 更新生产系统信息
                if 'current_production_system' in data:
                    evaluation.current_production_system = data['current_production_system']
                
                if 'production_systems' in data:
                    evaluation.production_systems = data['production_systems']
                
                # 更新安全指标
                indicators = data.get('indicators', {})
                for field_name, value in indicators.items():
                    if hasattr(evaluation, field_name):
                        try:
                            validated_value = validate_indicator_value(value, field_name)
                            setattr(evaluation, field_name, validated_value)
                        except ValidationError as ve:
                            return create_error_response(str(ve), 400, 'INVALID_INDICATOR_VALUE')
                
                # 验证并保存
                evaluation.full_clean()
                evaluation.save()
                
                # 重新计算综合得分和安全等级并保存
                comprehensive_score = evaluation.calculate_comprehensive_score()
                safety_level = evaluation.get_safety_level()
                evaluation.comprehensive_score = comprehensive_score
                evaluation.safety_level = safety_level
                evaluation.save(update_fields=['comprehensive_score', 'safety_level'])
                
                logger.info(f"成功更新安全评价记录: {evaluation.evaluation_id}")
                
                # 自动创建隐患追踪任务（如果安全等级为C级或D级）
                created_hazard_tasks = auto_create_hazard_tracking_from_evaluation(evaluation)
                
                return create_success_response({
                    'id': evaluation.id,
                    'evaluation_id': evaluation.evaluation_id,
                    'mine_name': evaluation.mine_name,
                    'evaluator_name': evaluation.evaluator_name,
                    'evaluation_date': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else None,
                    'comprehensive_score': round(comprehensive_score, 4),
                    'safety_level': safety_level,
                    'updated_at': evaluation.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
                    'hazard_tasks_created': len(created_hazard_tasks),
                    'hazard_tasks': created_hazard_tasks if created_hazard_tasks else None,
                }, '安全评价更新成功' + (f'，已自动创建{len(created_hazard_tasks)}个隐患追踪任务' if created_hazard_tasks else ''))
            
        except ValidationError as ve:
            logger.warning(f"更新安全评价数据验证失败 (ID: {evaluation_id}): {ve}")
            return create_error_response(f'数据验证失败: {ve}', 400, 'VALIDATION_ERROR')
        except Exception as e:
            logger.error(f"更新安全评价失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
            return create_error_response('更新评价失败，请稍后重试', 500, 'UPDATE_ERROR')
    
    elif request.method == 'DELETE':
        try:
            with transaction.atomic():
                evaluation_id_str = evaluation.evaluation_id
                evaluation.delete()
                
                logger.info(f"成功删除安全评价记录: {evaluation_id_str}")
                
                return create_success_response(message='安全评价删除成功')
            
        except Exception as e:
            logger.error(f"删除安全评价失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
            return create_error_response('删除评价失败，请稍后重试', 500, 'DELETE_ERROR')


@require_http_methods(["GET"])
def get_default_indicators(request: HttpRequest) -> JsonResponse:
    """
    获取默认安全指标值
    
    用于前端表单初始化，提供所有安全指标的标准默认值。
    这些值基于行业经验和历史数据统计得出。
    
    Returns:
        JsonResponse: 包含所有默认指标值的JSON响应
    """
    try:
        # 定义标准化的默认安全指标值（0-100范围）
        default_indicators = {
            # 人员因素指标
            'worker_safety_awareness': 75.0,          # 工人安全意识与操作能力
            'management_capability': 80.0,            # 管理人员的管理能力
            
            # 设备完好率指标  
            'mining_equipment_integrity': 85.0,       # 采掘设备完好率
            'ventilation_equipment_integrity': 90.0,   # 矿井通风设备完好率
            'gas_monitoring_equipment_integrity': 88.0, # 瓦斯监测设备完好率
            'fire_prevention_equipment_integrity': 82.0, # 防火及消防设施完好率
            'drainage_equipment_integrity': 87.0,      # 井下排水设备完好率
            'hoisting_equipment_integrity': 91.0,      # 矿井提升设备完好率
            'power_system_integrity': 89.0,           # 供电系统设备完好率
            
            # 环境与工艺指标
            'air_supply_demand_ratio': 78.0,          # 风量供需比
            'roof_management_difficulty': 70.0,       # 顶板管理难易程度
            'coal_spontaneous_combustion_tendency': 65.0, # 煤层自燃发火倾向性
            
            # 管理制度指标
            'safety_management_implementation': 83.0,  # 安全管理制度及落实率
            'emergency_response_completeness': 77.0,   # 应急响应机制完善率
            'safety_inspection_implementation': 81.0,  # 安全检查整改落实率
        }
        
        # 添加指标说明信息
        indicator_descriptions = {
            'worker_safety_awareness': '工人安全意识与操作能力评价',
            'management_capability': '管理人员的管理能力评价',
            'mining_equipment_integrity': '采掘设备完好率',
            'ventilation_equipment_integrity': '矿井通风设备完好率',
            'gas_monitoring_equipment_integrity': '瓦斯监测设备完好率',
            'fire_prevention_equipment_integrity': '防火及消防设施完好率',
            'drainage_equipment_integrity': '井下排水设备完好率',
            'hoisting_equipment_integrity': '矿井提升设备完好率',
            'power_system_integrity': '供电系统设备完好率',
            'air_supply_demand_ratio': '风量供需比',
            'roof_management_difficulty': '顶板管理难易程度',
            'coal_spontaneous_combustion_tendency': '煤层自燃发火倾向性',
            'safety_management_implementation': '安全管理制度及落实率',
            'emergency_response_completeness': '应急响应机制完善率',
            'safety_inspection_implementation': '安全检查整改落实率',
        }
        
        # 添加新增矿山基本信息字段的默认值
        default_mine_info = {
            'affiliated_enterprise': '',
            'production_capacity': 100.0,
            'service_life': 30,
            'development_methods': [],
            'transport_method': '',
            'current_production_system': 'mining_system',
            'production_systems': {
                'mining_system': {
                    'system_name': '开采系统',
                    'function_description': '矿石开采',
                    'main_facilities': '掘进机、采煤机',
                    'operation_status': 'normal',
                    'safety_hazards': '顶板监测需加强'
                },
                'ventilation_system': {
                    'system_name': '通风系统',
                    'function_description': '矿井通风',
                    'main_facilities': '主扇风机、局部通风机',
                    'operation_status': 'normal',
                    'safety_hazards': '通风阻力较大'
                },
                'gas_prevention_system': {
                    'system_name': '瓦斯防治系统',
                    'function_description': '瓦斯监测与防治',
                    'main_facilities': '瓦斯监测仪、抽放设备',
                    'operation_status': 'normal',
                    'safety_hazards': '监测点覆盖不全'
                },
                'drainage_system': {
                    'system_name': '排水系统',
                    'function_description': '矿井排水',
                    'main_facilities': '主排水泵、水仓',
                    'operation_status': 'normal',
                    'safety_hazards': '排水能力需提升'
                },
                'hoisting_transport_system': {
                    'system_name': '提升运输系统',
                    'function_description': '物料提升运输',
                    'main_facilities': '提升机、运输机',
                    'operation_status': 'normal',
                    'safety_hazards': '提升设备老化'
                },
                'power_system': {
                    'system_name': '供电系统',
                    'function_description': '矿井供电',
                    'main_facilities': '变压器、配电柜',
                    'operation_status': 'normal',
                    'safety_hazards': '供电线路需检修'
                },
                'fire_explosion_prevention_system': {
                    'system_name': '防火防爆系统',
                    'function_description': '防火防爆',
                    'main_facilities': '消防设备、防爆设备',
                    'operation_status': 'normal',
                    'safety_hazards': '消防设备配置不足'
                }
            }
        }
        
        response_data = {
            'indicators': default_indicators,
            'descriptions': indicator_descriptions,
            'mine_basic_info': default_mine_info,
            'total_count': len(default_indicators),
            'value_range': {
                'min': MIN_INDICATOR_VALUE,
                'max': MAX_INDICATOR_VALUE
            }
        }
        
        return create_success_response(response_data, '成功获取默认指标值')
        
    except Exception as e:
        logger.error(f"获取默认指标值失败: {str(e)}", exc_info=True)
        return create_error_response('获取默认指标值失败', 500, 'DEFAULT_INDICATORS_ERROR')


@require_http_methods(["GET"])
def calculate_evaluation_score(request: HttpRequest, evaluation_id: int) -> JsonResponse:
    """
    计算指定评价的综合得分和安全等级
    
    根据评价记录中的各项安全指标，计算综合安全得分和对应的安全等级。
    
    Args:
        evaluation_id: 安全评价记录的ID
    
    Returns:
        JsonResponse: 包含计算结果的JSON响应
    """
    try:
        evaluation = get_object_or_404(SafetyEvaluation, pk=evaluation_id)
    except Exception as e:
        logger.warning(f"安全评价记录不存在: ID={evaluation_id}")
        return create_error_response('评价记录不存在', 404, 'EVALUATION_NOT_FOUND')
    
    try:
        # 执行综合得分计算
        comprehensive_score = evaluation.calculate_comprehensive_score()
        safety_level = evaluation.get_safety_level()
        indicators = evaluation.get_safety_indicators_dict()
        
        # 构建详细计算结果
        calculation_result = {
            'evaluation_info': {
                'id': evaluation.id,
                'evaluation_id': evaluation.evaluation_id,
                'mine_name': evaluation.mine_name,
                'evaluator_name': evaluation.evaluator_name,
                'evaluation_date': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else None,
            },
            'calculation_results': {
                'comprehensive_score': round(comprehensive_score, 4),
                'safety_level': safety_level,
                'score_percentage': round(comprehensive_score * 100, 2),
            },
            'indicators': indicators,
            'calculation_timestamp': timezone.now().strftime('%Y-%m-%d %H:%M:%S'),
        }
        
        logger.info(f"成功计算评价得分: {evaluation.evaluation_id}, 得分: {comprehensive_score}")
        
        return create_success_response(calculation_result, '评价得分计算完成')
        
    except Exception as e:
        logger.error(f"计算评价得分失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
        return create_error_response('计算评价得分失败，请稍后重试', 500, 'CALCULATION_ERROR')


@require_http_methods(["GET"])
def get_evaluation_statistics(request: HttpRequest) -> JsonResponse:
    """
    获取安全评价统计数据
    
    提供系统中安全评价数据的综合统计信息，包括：
    - 总体数量统计
    - 按类别和区域的分布统计
    - 平均得分和安全等级分布
    - 时间趋势分析
    
    Returns:
        JsonResponse: 包含统计数据的JSON响应
    """
    try:
        # 基础统计数据
        total_count = SafetyEvaluation.objects.count()
        
        if total_count == 0:
            return create_success_response({
                'total_count': 0,
                'average_score': 0,
                'category_distribution': [],
                'region_distribution': [],
                'safety_level_distribution': {},
                'message': '暂无评价数据'
            }, '统计数据获取成功')
        
        # 按评价类别统计
        category_stats = list(SafetyEvaluation.objects.values('evaluation_category').annotate(
            count=Count('id'),
            category_display=Count('evaluation_category')  # 占位，后续处理显示名称
        ))
        
        # 处理类别显示名称
        for stat in category_stats:
            try:
                temp_obj = SafetyEvaluation(evaluation_category=stat['evaluation_category'])
                stat['category_display'] = temp_obj.get_evaluation_category_display()
            except:
                stat['category_display'] = stat['evaluation_category']
        
        # 按区域统计
        region_stats = list(SafetyEvaluation.objects.values('region').annotate(
            count=Count('id')
        ))
        
        # 处理区域显示名称
        for stat in region_stats:
            try:
                temp_obj = SafetyEvaluation(region=stat['region'])
                stat['region_display'] = temp_obj.get_region_display()
            except:
                stat['region_display'] = stat['region']
        
        # 计算平均综合得分和安全等级分布
        evaluations = SafetyEvaluation.objects.all()
        scores = []
        safety_levels = {}
        
        for evaluation in evaluations:
            try:
                score = evaluation.calculate_comprehensive_score()
                scores.append(score)
                
                level = evaluation.get_safety_level()
                safety_levels[level] = safety_levels.get(level, 0) + 1
            except Exception as eval_error:
                logger.warning(f"计算评价 {evaluation.id} 统计数据时出错: {eval_error}")
                continue
        
        # 计算统计指标
        avg_score = sum(scores) / len(scores) if scores else 0
        max_score = max(scores) if scores else 0
        min_score = min(scores) if scores else 0
        
        # 最近30天的评价数量
        from django.utils import timezone
        from datetime import timedelta
        thirty_days_ago = timezone.now().date() - timedelta(days=30)
        recent_count = SafetyEvaluation.objects.filter(
            created_at__date__gte=thirty_days_ago
        ).count()
        
        statistics_data = {
            'summary': {
                'total_count': total_count,
                'recent_count': recent_count,
                'average_score': round(avg_score, 4),
                'max_score': round(max_score, 4),
                'min_score': round(min_score, 4),
                'score_range': round(max_score - min_score, 4) if scores else 0,
            },
            'distributions': {
                'category_distribution': category_stats,
                'region_distribution': region_stats,
                'safety_level_distribution': safety_levels,
            },
            'metadata': {
                'calculation_timestamp': timezone.now().strftime('%Y-%m-%d %H:%M:%S'),
                'data_range': '全部历史数据',
                'recent_period': '最近30天',
            }
        }
        
        logger.info(f"成功生成统计数据: 总计 {total_count} 条评价记录")
        
        return create_success_response(statistics_data, '统计数据获取成功')
        
    except Exception as e:
        logger.error(f"获取统计数据失败: {str(e)}", exc_info=True)
        return create_error_response('获取统计数据失败，请稍后重试', 500, 'STATISTICS_ERROR')


@require_http_methods(["GET"])
def generate_safety_report(request: HttpRequest, evaluation_id: int) -> JsonResponse:
    """
    生成安全评价报告
    
    根据安全评价记录生成完整的安全报告，包含：
    - 矿山基本信息
    - 安全指标评分与模型计算
    - 安全等级判定（使用AHP-MIV-BP模型预测）
    - 整改建议（根据低分指标自动生成）
    
    Args:
        evaluation_id: 安全评价记录的ID
    
    Returns:
        JsonResponse: 包含完整安全报告的JSON响应
    """
    try:
        evaluation = get_object_or_404(SafetyEvaluation, pk=evaluation_id)
    except Exception as e:
        logger.warning(f"安全评价记录不存在: ID={evaluation_id}")
        return create_error_response('评价记录不存在', 404, 'EVALUATION_NOT_FOUND')
    
    try:
        import random
        from datetime import datetime
        from .model_manager import predict_safety_level
        
        # 获取评价指标数据并归一化为0-1范围
        indicators_dict = evaluation.get_safety_indicators_dict()
        
        # 按照model_handler要求的顺序构建特征列表（归一化为0-1）
        features = [
            indicators_dict['worker_safety_awareness'] / 100.0,
            indicators_dict['management_capability'] / 100.0,
            indicators_dict['mining_equipment_integrity'] / 100.0,
            indicators_dict['ventilation_equipment_integrity'] / 100.0,
            indicators_dict['gas_monitoring_equipment_integrity'] / 100.0,
            indicators_dict['fire_prevention_equipment_integrity'] / 100.0,
            indicators_dict['drainage_equipment_integrity'] / 100.0,
            indicators_dict['hoisting_equipment_integrity'] / 100.0,
            indicators_dict['power_system_integrity'] / 100.0,
            indicators_dict['air_supply_demand_ratio'] / 100.0,
            indicators_dict['roof_management_difficulty'] / 100.0,
            indicators_dict['coal_spontaneous_combustion_tendency'] / 100.0,
            indicators_dict['safety_management_implementation'] / 100.0,
            indicators_dict['emergency_response_completeness'] / 100.0,
            indicators_dict['safety_inspection_implementation'] / 100.0,
        ]
        
        # 使用单例模式预测安全等级
        predicted_level = predict_safety_level(features)
        
        # 确保等级显示一致（模型已返回正确格式）
        safety_level = predicted_level
        
        # 计算综合得分
        comprehensive_score = evaluation.calculate_comprehensive_score()
        
        # 注意：不在这里直接保存安全等级到数据库
        # 安全等级将通过前端调用update_safety_level API来更新
        # 这样可以确保前端有控制权，并且可以处理更新失败的情况
        
        # 获取评价指标数据
        indicators_dict = evaluation.get_safety_indicators_dict()
        
        # 指标中文名称映射
        indicators_mapping = {
            'management_capability': '管理人员管理能力',
            'worker_safety_awareness': '工人安全意识与操作能力', 
            'mining_equipment_integrity': '采掘设备完好率',
            'ventilation_equipment_integrity': '矿井通风设备完好率',
            'gas_monitoring_equipment_integrity': '瓦斯监测设备完好率',
            'fire_prevention_equipment_integrity': '防火及消防设施完好率',
            'drainage_equipment_integrity': '井下排水设备完好率',
            'hoisting_equipment_integrity': '矿井提升设备完好率',
            'power_system_integrity': '供电系统设备完好率',
            'air_supply_demand_ratio': '风量供需比',
            'roof_management_difficulty': '顶板管理难易程度',
            'coal_spontaneous_combustion_tendency': '煤层自燃发火倾向性',
            'safety_management_implementation': '安全管理制度及落实率',
            'emergency_response_completeness': '应急响应机制完善率',
            'safety_inspection_implementation': '安全检查整改落实率',
        }
        
        # 整改建议模板库（触发条件调整为0-100范围）
        remediation_templates = {
            'management_capability': {
                'condition': '能力评分 < 50',
                'level': '较危险',
                'suggestion': '系统检测到矿井管理人员管理能力存在不足。请加强管理人员安全管理培训，优化安全职责分工，并落实定期巡查与监督机制。整改完成后请上传培训记录及管理改进方案。'
            },
            'worker_safety_awareness': {
                'condition': '安全意识评分 < 50',
                'level': '较危险',
                'suggestion': '模型分析表明工人安全意识不足。请开展班组安全教育与实操培训，提升员工安全操作能力，确保规范作业。整改完成后上传培训签到表及照片。'
            },
            'mining_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '采掘设备状态异常。请进行巡检、维修，落实预防性维护制度，确保设备安全运行。整改完成后上传检修清单。'
            },
            'ventilation_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '通风设备存在异常。请检查主扇、辅扇及管道，清理障碍物，确保风量充足和通风稳定。整改完成后上传检查及维修记录。'
            },
            'gas_monitoring_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '瓦斯监测设备异常。请校准监测仪器，保证实时在线监控及报警功能有效。整改完成后上传校准记录。'
            },
            'fire_prevention_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '消防设施存在缺陷。请检查灭火器、喷淋系统、消防水源，并修复或更换损坏设备。整改完成后上传测试记录。'
            },
            'drainage_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '井下排水设备存在故障。请检查水泵、管路及阀门，确保排水畅通。整改完成后上传运行记录。'
            },
            'hoisting_equipment_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '矿井提升设备存在故障风险。请检查钢丝绳、制动装置及安全保护措施。整改完成后上传检查记录。'
            },
            'power_system_integrity': {
                'condition': '完好率 < 50',
                'level': '危险',
                'suggestion': '供电系统设备异常。请检查供电线路、开关及设备，确保供电可靠。整改完成后上传检查记录。'
            },
            'air_supply_demand_ratio': {
                'condition': '比值 < 50',
                'level': '较危险',
                'suggestion': '风量不足。请优化通风系统布局，确保工作面风量满足安全要求。整改完成后上传调整记录。'
            },
            'roof_management_difficulty': {
                'condition': '管理难度评分 < 50',
                'level': '较危险',
                'suggestion': '顶板管理存在风险。请加强顶板支护、监测及巡查，确保顶板稳定。整改完成后上传检查记录。'
            },
            'coal_spontaneous_combustion_tendency': {
                'condition': '倾向性评分 < 50',
                'level': '较危险', 
                'suggestion': '采取惰性气体注入、充填隔离等技术防止自燃发火。'
            },
            'safety_management_implementation': {
                'condition': '落实率 < 50',
                'level': '较危险',
                'suggestion': '安全制度执行不到位。请完善制度、明确责任、强化监督，整改后上传制度落实记录。'
            },
            'emergency_response_completeness': {
                'condition': '完善率 < 50',
                'level': '较危险',
                'suggestion': '应急预案不完善。请完善应急响应措施，组织演练并上传演练记录。'
            },
            'safety_inspection_implementation': {
                'condition': '落实率 < 50',
                'level': '较危险',
                'suggestion': '隐患整改滞后。请建立闭环管理，确保所有隐患按时整改并复核，上传整改结果。'
            }
        }
        
        # 构建安全指标评分表
        indicator_scores = []
        low_score_indicators = []
        
        for i, (field_name, chinese_name) in enumerate(indicators_mapping.items(), 1):
            value = indicators_dict.get(field_name, 0)
            # 随机生成一些模拟的权重和期望值
            weight = round(random.uniform(0.05, 0.1), 3)
            expected_output = round(random.uniform(0.7, 0.9), 3)
            model_output = round(value + random.uniform(-0.1, 0.1), 3)
            deviation = round(abs(expected_output - model_output), 3)
            
            indicator_scores.append({
                '序号': i,
                '指标名称': chinese_name,
                '指标值': round(value, 3),
                '权重': weight,
                '期望输出值': expected_output,
                '模型输出值': model_output,
                '偏差/误差': deviation
            })
            
            # 检查是否为低分指标（阈值50）
            if value < 50.0:
                low_score_indicators.append(field_name)
        
        # 生成整改建议
        remediation_suggestions = []
        for field_name in low_score_indicators:
            if field_name in remediation_templates:
                template = remediation_templates[field_name]
                remediation_suggestions.append({
                    '指标名称': indicators_mapping[field_name],
                    '触发条件': template['condition'],
                    '安全等级': template['level'],
                    '建议内容': template['suggestion']
                })
        
        # 使用数据库中的evaluation_id作为报告编号
        report_id = evaluation.evaluation_id
        
        # 构建完整安全报告
        safety_report = {
            '报告基本信息': {
                '报告编号': report_id,
                '评价日期': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else datetime.now().strftime('%Y-%m-%d'),
                '矿山名称': evaluation.mine_name,
                '矿山类型': evaluation.get_evaluation_category_display(),
                '所属区域': evaluation.get_region_display(),
                '评价人': evaluation.evaluator_name
            },
            
            '矿山基本信息': {
                '信息项': {
                    '矿山编号': f"MINE{datetime.now().strftime('%Y%m%d')}-{str(evaluation.id).zfill(3)}",
                    '矿山名称': evaluation.mine_name,
                    '所属区域': evaluation.get_region_display(),
                    '联系人': evaluation.evaluator_name,
                    '联系电话': '待补充',
                    '矿山类型': evaluation.get_evaluation_category_display(),
                    '备注': '基于AHP-MIV-BP模型进行安全评价'
                }
            },
            
            '安全指标评分与模型计算': indicator_scores,
            
            '安全等级判定': {
                '总体安全等级': safety_level,
                '综合得分': round(comprehensive_score, 4),
                '低分指标数量': len(low_score_indicators),
                '建议整改指标': ', '.join([indicators_mapping[field] for field in low_score_indicators]) if low_score_indicators else '无'
            },
            
            '整改建议': remediation_suggestions,
            
            '报告元数据': {
                '生成时间': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                '算法版本': 'AHP-MIV-BP v1.0',
                '报告格式': 'JSON',
                '数据来源': '矿山安全评价系统',
                '阈值设定': '低分指标阈值: 50.0'
            }
        }
        
        # 如果有整改建议，自动创建隐患追踪任务
        created_hazard_tasks = []
        if remediation_suggestions:
            try:
                # 导入隐患追踪模型
                from hazard.models import HazardTracking
                from django.db import transaction
                from datetime import timedelta
                
                with transaction.atomic():
                    for suggestion in remediation_suggestions:
                        try:
                            # 验证必要字段
                            indicator_name = suggestion.get('指标名称', '').strip()
                            trigger_condition = suggestion.get('触发条件', '').strip()
                            remediation_content = suggestion.get('建议内容', '').strip()
                            
                            if not indicator_name or not remediation_content:
                                logger.warning(f"跳过无效的整改建议: {suggestion}")
                                continue
                            
                            # 设置截止日期为指派日期后7天
                            deadline = timezone.now() + timedelta(days=7)
                            
                            # 根据安全等级确定等级
                            hazard_safety_level = 'D级(较差)' if suggestion.get('安全等级') == '危险' else 'C级(一般)'
                            
                            hazard = HazardTracking.objects.create(
                                mine_name=evaluation.mine_name,
                                indicator_name=indicator_name,
                                safety_level=hazard_safety_level,
                                trigger_condition=trigger_condition,
                                remediation_suggestion=remediation_content,
                                responsible_person='待指派',
                                deadline_date=deadline,
                                safety_evaluation=evaluation,
                                remarks=f'由安全评价报告自动生成（报告编号: {report_id}）'
                            )
                            
                            created_hazard_tasks.append({
                                'task_id': hazard.task_id,
                                'indicator_name': hazard.indicator_name,
                                'safety_level': hazard.safety_level,
                            })
                            
                            logger.debug(f"成功创建隐患追踪任务: {hazard.task_id}")
                            
                        except Exception as task_error:
                            logger.warning(f"创建隐患任务失败，建议: {suggestion.get('指标名称', '未知')}，错误: {task_error}")
                            continue
                            
                    if created_hazard_tasks:
                        logger.info(f"成功创建 {len(created_hazard_tasks)} 个隐患追踪任务")
                    else:
                        logger.info("未创建隐患追踪任务，可能因为没有有效的整改建议")
                    
            except Exception as hazard_error:
                logger.error(f"创建隐患追踪任务时发生系统错误: {hazard_error}", exc_info=True)
                # 不影响报告生成，继续返回报告
        
        # 在报告中添加隐患任务信息
        if created_hazard_tasks:
            safety_report['隐患追踪任务'] = {
                '已创建任务数量': len(created_hazard_tasks),
                '任务列表': created_hazard_tasks,
                '说明': '系统已根据整改建议自动创建隐患追踪任务，请前往隐患管理模块查看和处理。'
            }
        
        logger.info(f"成功生成安全报告: {report_id} for evaluation {evaluation.evaluation_id}, 创建隐患任务 {len(created_hazard_tasks)} 个")
        
        # 返回包含隐患任务信息的成功响应
        response_data = safety_report.copy()
        response_data['meta_info'] = {
            'hazard_tasks_created': len(created_hazard_tasks),
            'hazard_tasks': created_hazard_tasks
        }
        
        return create_success_response(response_data, '评估完成！已自动创建相应的隐患追踪任务')
        
    except Exception as e:
        logger.error(f"生成安全报告失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
        return create_error_response('生成安全报告失败，请稍后重试', 500, 'REPORT_GENERATION_ERROR')


@require_http_methods(["POST"])
def update_safety_level(request: HttpRequest, evaluation_id: int) -> JsonResponse:
    """
    更新安全评价的安全等级
    
    根据算法计算结果更新数据库中的安全等级和综合得分
    
    Args:
        evaluation_id: 安全评价记录的ID
    
    Request Body:
        {
            "safety_level": "A级(优秀)",
            "comprehensive_score": 0.85
        }
    
    Returns:
        JsonResponse: 包含更新结果的JSON响应
    """
    try:
        evaluation = get_object_or_404(SafetyEvaluation, pk=evaluation_id)
    except Exception as e:
        logger.warning(f"安全评价记录不存在: ID={evaluation_id}")
        return create_error_response('评价记录不存在', 404, 'EVALUATION_NOT_FOUND')
    
    try:
        # 解析请求数据
        try:
            data = json.loads(request.body.decode('utf-8'))
        except (json.JSONDecodeError, UnicodeDecodeError):
            return create_error_response('请求数据格式错误', 400, 'INVALID_JSON')
        
        # 验证必要字段
        safety_level = data.get('safety_level', '').strip()
        comprehensive_score = data.get('comprehensive_score')
        
        if not safety_level:
            return create_error_response('安全等级不能为空', 400, 'MISSING_SAFETY_LEVEL')
        
        if comprehensive_score is None:
            return create_error_response('综合得分不能为空', 400, 'MISSING_COMPREHENSIVE_SCORE')
        
        # 验证安全等级格式
        valid_levels = ['A级(优秀)', 'B级(良好)', 'C级(一般)', 'D级(较差)']
        if safety_level not in valid_levels:
            return create_error_response(f'无效的安全等级: {safety_level}', 400, 'INVALID_SAFETY_LEVEL')
        
        # 验证综合得分范围
        if not isinstance(comprehensive_score, (int, float)) or comprehensive_score < 0 or comprehensive_score > 1:
            return create_error_response('综合得分必须在0-1之间', 400, 'INVALID_COMPREHENSIVE_SCORE')
        
        # 使用事务更新记录
        with transaction.atomic():
            evaluation.safety_level = safety_level
            evaluation.comprehensive_score = comprehensive_score
            evaluation.save(update_fields=['safety_level', 'comprehensive_score'])
            
            logger.info(f"成功更新安全等级: {evaluation.evaluation_id}, 等级: {safety_level}, 得分: {comprehensive_score}")
            
            return create_success_response({
                'id': evaluation.id,
                'evaluation_id': evaluation.evaluation_id,
                'safety_level': evaluation.safety_level,
                'comprehensive_score': evaluation.comprehensive_score,
                'updated_at': evaluation.updated_at.strftime('%Y-%m-%d %H:%M:%S')
            }, '安全等级更新成功')
            
    except Exception as e:
        logger.error(f"更新安全等级失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
        return create_error_response('更新安全等级失败，请稍后重试', 500, 'UPDATE_SAFETY_LEVEL_ERROR')


@require_http_methods(["GET"])
def get_safety_reports_list(request: HttpRequest) -> JsonResponse:
    """
    获取安全报告列表
    
    支持按报告编号或矿山名称检索安全报告，用于报告管理页面。
    
    查询参数：
        - filter_type: 检索类型 ('report_id' 或 'mine_name')
        - keyword: 检索关键词（模糊匹配）
        - page: 页码（默认1）
        - page_size: 每页大小（默认10，最大100）
    
    Returns:
        JsonResponse: 包含报告列表的JSON响应，每个报告包含：
        - ReportID: 报告编号
        - MineName: 矿山名称
        - EvaluationDate: 评价日期
        - Evaluator: 评价人
        - RiskLevel: 安全等级
        - evaluation_id: 评价记录ID（用于预览和导出）
    """
    try:
        # 验证分页参数
        page, page_size = validate_pagination_params(request)
        
        # 获取检索参数
        filter_type = request.GET.get('filter_type', '').strip()
        keyword = request.GET.get('keyword', '').strip()
        
        logger.info(f"获取安全报告列表 - filter_type: {filter_type}, keyword: {keyword}, page: {page}")
        
        # 构建查询集
        queryset = SafetyEvaluation.objects.select_related().order_by('-created_at')
        
        # 应用检索条件
        if keyword and filter_type:
            if filter_type == 'report_id':
                # 按报告编号检索（模糊匹配）
                queryset = queryset.filter(evaluation_id__icontains=keyword)
            elif filter_type == 'mine_name':
                # 按矿山名称检索（模糊匹配）
                queryset = queryset.filter(mine_name__icontains=keyword)
            else:
                return create_error_response('无效的检索类型，仅支持 report_id 或 mine_name', 400, 'INVALID_FILTER_TYPE')
        
        # 分页处理
        paginator = Paginator(queryset, page_size)
        
        if page > paginator.num_pages and paginator.num_pages > 0:
            return create_error_response('请求的页码超出范围', 404, 'PAGE_OUT_OF_RANGE')
        
        page_obj = paginator.get_page(page)
        
        # 构建报告列表响应数据
        reports = []
        for evaluation in page_obj:
            try:
                # 使用数据库中的evaluation_id作为报告编号
                report_id = evaluation.evaluation_id
                
                # 使用存储的安全等级，如果没有则计算
                risk_level = evaluation.get_safety_level()
                
                report_data = {
                    'ReportID': report_id,
                    'MineName': evaluation.mine_name,
                    'EvaluationDate': evaluation.evaluation_date.strftime('%Y-%m-%d') if evaluation.evaluation_date else evaluation.created_at.strftime('%Y-%m-%d'),
                    'Evaluator': evaluation.evaluator_name,
                    'RiskLevel': risk_level,
                    'evaluation_id': evaluation.id,  # 用于预览和导出
                    'comprehensive_score': round(evaluation.calculate_comprehensive_score(), 4),
                    'created_at': evaluation.created_at.strftime('%Y-%m-%d %H:%M:%S'),
                }
                reports.append(report_data)
                
            except Exception as eval_error:
                logger.warning(f"处理评价记录 {evaluation.id} 时出错: {eval_error}")
                continue
        
        # 分页信息
        pagination_info = {
            'current_page': page,
            'total_pages': paginator.num_pages,
            'total_count': paginator.count,
            'page_size': page_size,
            'has_next': page_obj.has_next(),
            'has_previous': page_obj.has_previous(),
        }
        
        response_data = {
            'reports': reports,
            'pagination': pagination_info,
            'search_params': {
                'filter_type': filter_type,
                'keyword': keyword,
            }
        }
        
        logger.info(f"成功获取安全报告列表，共 {len(reports)} 条记录")
        
        return create_success_response(response_data, '成功获取安全报告列表')
        
    except Exception as e:
        logger.error(f"获取安全报告列表失败: {str(e)}", exc_info=True)
        return create_error_response('获取安全报告列表失败，请稍后重试', 500, 'REPORTS_LIST_ERROR')


@require_http_methods(["GET"])
def export_evaluation_report(request: HttpRequest, evaluation_id: int) -> JsonResponse:
    """
    导出安全评价报告
    
    生成指定评价记录的详细报告，包含完整的评价信息、
    安全指标数据和计算结果。支持JSON格式，可扩展为PDF等格式。
    
    Args:
        evaluation_id: 安全评价记录的ID
    
    Returns:
        JsonResponse: 包含完整报告数据的JSON响应
    """
    try:
        evaluation = get_object_or_404(SafetyEvaluation, pk=evaluation_id)
    except Exception as e:
        logger.warning(f"安全评价记录不存在: ID={evaluation_id}")
        return create_error_response('评价记录不存在', 404, 'EVALUATION_NOT_FOUND')
    
    try:
        # 构建完整的评价报告
        comprehensive_score = evaluation.calculate_comprehensive_score()
        safety_level = evaluation.get_safety_level()
        
        # 报告基本信息
        report_header = {
            'report_title': f'矿山安全评价报告 - {evaluation.mine_name}',
            'report_id': f'RPT-{evaluation.evaluation_id}',
            'generation_time': timezone.now().strftime('%Y年%m月%d日 %H时%M分'),
            'report_version': '1.0',
        }
        
        # 评价基本信息
        evaluation_info = {
            '评价编号': evaluation.evaluation_id,
            '矿山名称': evaluation.mine_name,
            '评价人员': evaluation.evaluator_name,
            '评价日期': evaluation.evaluation_date.strftime('%Y年%m月%d日') if evaluation.evaluation_date else '未指定',
            '所属区域': evaluation.get_region_display(),
            '评价类别': evaluation.get_evaluation_category_display(),
            '创建时间': evaluation.created_at.strftime('%Y年%m月%d日 %H时%M分'),
            '最后更新': evaluation.updated_at.strftime('%Y年%m月%d日 %H时%M分'),
        }
        
        # 安全指标详情（中文名称对应）
        indicators_mapping = {
            'worker_safety_awareness': '工人安全意识与操作能力',
            'management_capability': '管理人员的管理能力',
            'mining_equipment_integrity': '采掘设备完好率',
            'ventilation_equipment_integrity': '矿井通风设备完好率',
            'gas_monitoring_equipment_integrity': '瓦斯监测设备完好率',
            'fire_prevention_equipment_integrity': '防火及消防设施完好率',
            'drainage_equipment_integrity': '井下排水设备完好率',
            'hoisting_equipment_integrity': '矿井提升设备完好率',
            'power_system_integrity': '供电系统设备完好率',
            'air_supply_demand_ratio': '风量供需比',
            'roof_management_difficulty': '顶板管理难易程度',
            'coal_spontaneous_combustion_tendency': '煤层自燃发火倾向性',
            'safety_management_implementation': '安全管理制度及落实率',
            'emergency_response_completeness': '应急响应机制完善率',
            'safety_inspection_implementation': '安全检查整改落实率',
        }
        
        # 构建指标数据
        safety_indicators = {}
        indicators_dict = evaluation.get_safety_indicators_dict()
        
        for field_name, chinese_name in indicators_mapping.items():
            value = indicators_dict.get(field_name, 0)
            safety_indicators[chinese_name] = {
                'value': round(value, 4),
                'percentage': f"{round(value * 100, 2)}%",
                'field_name': field_name
            }
        
        # 评价结果
        evaluation_result = {
            '综合得分': round(comprehensive_score, 4),
            '得分百分比': f"{round(comprehensive_score * 100, 2)}%",
            '安全等级': safety_level,
            '等级说明': evaluation._get_safety_level_description(safety_level),
        }
        
        # 组装完整报告
        report_data = {
            'header': report_header,
            'evaluation_info': evaluation_info,
            'safety_indicators': safety_indicators,
            'evaluation_result': evaluation_result,
            'report_summary': {
                '评价概述': f'{evaluation.mine_name}安全评价得分为{round(comprehensive_score * 100, 2)}分，安全等级为{safety_level}',
                '主要建议': '请根据各项指标得分情况，重点关注得分较低的安全指标，制定针对性的改进措施。',
                '数据来源': '本报告基于矿山安全评价系统中的实际数据生成',
            },
            'metadata': {
                'system_version': '矿山安全评价系统 v1.0',
                'calculation_method': 'AHP-MIV-BP综合评价方法',
                'export_format': 'JSON',
                'file_encoding': 'UTF-8',
            }
        }
        
        logger.info(f"成功导出评价报告: {evaluation.evaluation_id}")
        
        return create_success_response(report_data, '评价报告导出成功')
        
    except Exception as e:
        logger.error(f"导出评价报告失败 (ID: {evaluation_id}): {str(e)}", exc_info=True)
        return create_error_response('导出报告失败，请稍后重试', 500, 'EXPORT_ERROR')


@require_http_methods(["GET"])
def get_model_status(request: HttpRequest) -> JsonResponse:
    """
    获取模型状态信息
    
    用于检查AHP-MIV-BP模型是否正常加载和可用
    
    Returns:
        JsonResponse: 包含模型状态信息的JSON响应
    """
    try:
        from .model_manager import get_model_info, is_model_available
        
        # 获取模型信息
        model_info = get_model_info()
        is_available = is_model_available()
        
        response_data = {
            'model_available': is_available,
            'model_info': model_info,
            'timestamp': timezone.now().strftime('%Y-%m-%d %H:%M:%S')
        }
        
        if is_available:
            return create_success_response(response_data, '模型状态正常')
        else:
            return create_success_response(response_data, '模型不可用，将使用默认安全等级')
            
    except Exception as e:
        logger.error(f"获取模型状态失败: {str(e)}", exc_info=True)
        return create_error_response('获取模型状态失败', 500, 'MODEL_STATUS_ERROR')